package com.deadlock8;
//  不同的线程分别占用对方需要的同步资源不放弃，
//  都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。


//两个StringBuffer对象s1和s2中添加字符。
// 线程1首先锁定s1，然后向s1中添加字符"a"，
// 接着锁定s2并向s2中添加字符"1"，然后休眠10毫秒。
// 在休眠结束后，线程1再次锁定s2并向s2中添加字符"2"。
//线程2首先锁定s2，然后向s1中添加字符"c"，
// 接着锁定s1并向s1中添加字符"d"，然后休眠10毫秒。
// 在休眠结束后，线程2再次锁定s1并向s1中添加字符"4"。
//
//由于线程1先锁定s1，然后锁定s2，而线程2先锁定s2，
// 然后锁定s1，所以这两个线程会按照不同的顺序执行。
// 最终，s1和s2的内容可能如下：
//
//s1: "abcd"
//s2: "1342"
public class DeadLockTest1 {
    public static void main(String[] args) {
        // 创建两个StringBuffer对象s1和s2
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

// 创建第一个线程，该线程将执行以下操作：
        new Thread() {
            @Override
            public void run() {
                // 使用synchronized关键字对s1进行同步，确保在同一时刻只有一个线程可以访问s1
                synchronized (s1) {
                    // 向s1中添加字符"a"
                    s1.append("a");
                    // 向s2中添加字符"1"
                    s2.append("1");
                    try {
                        // 让当前线程休眠10毫秒
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // 如果发生中断异常，抛出运行时异常
                        throw new RuntimeException(e);
                    }
                    // 再次使用synchronized关键字对s2进行同步，确保在同一时刻只有一个线程可以访问s2
                    synchronized (s2) {
                        // 向s1中添加字符"b"
                        s1.append("b");
                        // 向s2中添加字符"2"
                        s2.append("2");
                    }
                }
            }
        }.start(); // 启动第一个线程

// 创建第二个线程，该线程将执行以下操作：
        new Thread() {
            @Override
            public void run() {
                // 使用synchronized关键字对s2进行同步，确保在同一时刻只有一个线程可以访问s2
                synchronized (s2) {
                    // 向s1中添加字符"c"
                    s1.append("c");
                    // 向s2中添加字符"3"
                    s2.append("3");
                    try {
                        // 让当前线程休眠10毫秒
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // 如果发生中断异常，抛出运行时异常
                        throw new RuntimeException(e);
                    }
                    // 再次使用synchronized关键字对s1进行同步，确保在同一时刻只有一个线程可以访问s1
                    synchronized (s1) {
                        // 向s1中添加字符"d"
                        s1.append("d");
                        // 向s2中添加字符"4"
                        s2.append("4");
                    }
                }
            }
        }.start(); // 启动第二个线程


    }
}

